package com.shitou.shitouproduct.controller;

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Map;

import com.shitou.shitoucommons.annotation.CheckUserLogin;
import com.shitou.shitouproduct.entity.SpuInfoEntity;
import com.shitou.shitouproduct.exception.AddGroup;
import com.shitou.shitouproduct.vo.ProductInfoVo;
import io.swagger.annotations.ApiOperation;
import io.swagger.models.auth.In;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.BindingResult;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import com.shitou.shitouproduct.service.SpuInfoService;
import com.shitou.shitoucommons.utils.PageUtils;
import com.shitou.shitoucommons.utils.RespBean;



/**
 * spu信息
 *
 * @author 石头人
 * @email 3076767823@qq.com
 * @date 2023-03-04 18:03:45
 */
@RestController
@RequestMapping("shitouproduct/spuinfo")
public class SpuInfoController {
    @Autowired
    private SpuInfoService spuInfoService;

    /**
     * 列表
     */
    @RequestMapping("/list")
    public RespBean list(@RequestParam Map<String, Object> params){
        PageUtils page = spuInfoService.queryPage(params);

        return RespBean.success().put("page", page);
    }

    /**
     * 信息
     */
    @RequestMapping("/info/{id}")
    public RespBean info(@PathVariable("id") Long id){
        SpuInfoEntity spuInfo = spuInfoService.getById(id);

        return RespBean.success().put("spuInfo", spuInfo);
    }

    /**
     * 保存
     */
    @RequestMapping("/save")
    public RespBean save(@RequestBody SpuInfoEntity spuInfo){
        spuInfoService.save(spuInfo);

        return RespBean.success();
    }

    /**
     * 修改
     */
    @RequestMapping("/update")
    public RespBean update(@RequestBody SpuInfoEntity spuInfo){
        spuInfoService.updateById(spuInfo);

        return RespBean.success();
    }

    /**
     * 删除
     */
    @RequestMapping("/delete")
    public RespBean delete(@RequestBody Long[] ids){
        spuInfoService.removeByIds(Arrays.asList(ids));

        return RespBean.success();
    }



    /**
     * 添加关于spu的所有信息
     * @param productInfoVo 映射类
     * @see ProductInfoVo
     * @param bindingResult General interface that represents binding results
     * @return
     */
    @ApiOperation(value = "创建二手商品信息，创建所有关联的表，需要登陆校验")
//    @CheckUserLogin
    @PostMapping("/editMemberProduct")
    public RespBean editMemberProduct(@Validated(value = {AddGroup.class}) @RequestBody ProductInfoVo productInfoVo,
    BindingResult bindingResult){
        return spuInfoService.editMemberProduct(productInfoVo);
    }


    /**
     * 更新关于spu的所有信息--->通过spu和sku
     * @param productInfoVo 映射类
     * @see ProductInfoVo
     * @param result General interface that represents binding results
     * @return
     */
    @ApiOperation(value = "更新关于spu的所有信息--->通过spu和sku,需要登陆校验")
    @CheckUserLogin
    @PostMapping("/updateMemberProduct")
    public RespBean updateMemberProduct(@RequestBody ProductInfoVo productInfoVo, BindingResult result){
        return spuInfoService.updateMemberProduct(productInfoVo);
    }


    /**
     * 获得该用户发布的所有的商品
     *      // 包括已经售卖出去了的，正在售卖的，上架的，下架的,,, 状态为1的
     * @param productInfoVo 映射类
     * @see ProductInfoVo
     * @return RespBean
     */
    @ApiOperation(value = "获得该用户发布的所有的商品,包括已经售卖出去了的，正在售卖的，上架的，下架的,,, 状态为1的,需要登录校验")
    @CheckUserLogin(value = false)
    @PostMapping("/getProductByMember")
    public RespBean getProductByMember(@RequestBody ProductInfoVo productInfoVo){
        return spuInfoService.getProductByMember(productInfoVo);
    }


    /**
     * 通过spu_id获取单个商品信息
     * @param productInfoVo 映射类
     * @see ProductInfoVo
     * @return RespBean
     */
    @ApiOperation(value = "通过spu_id获取单个商品信息,xuyaodenglujy")
    @CheckUserLogin
    @PostMapping("/getProductBySpuId")
    public RespBean getProductBySpuId(@RequestBody ProductInfoVo productInfoVo){
        return spuInfoService.getProductBySpuId(productInfoVo);
    }


    /**
     * 更新商品的上下架状态
     * @param productInfoVo 映射类
     * @see ProductInfoVo
     * @return RespBean
     */
    @ApiOperation(value = "更新商品的上下架状态，需要登录校验")
    @CheckUserLogin
    @PostMapping("/updatePublishStatus")
    public RespBean updatePublishStatus(@RequestBody ProductInfoVo productInfoVo){
        return spuInfoService.updatePublishStatus(productInfoVo);
    }


    /**
     * 获得所有未出售且上架的二手商品
     *      用于首页展示
     * @return RespBean
     */
    @ApiOperation(value = "获得所有未出售且商家的二手商品")
    @CheckUserLogin(value = false)
    @PostMapping("/getAllProduct")
    public RespBean getAllProduct(){
        return spuInfoService.getAllProduct();
    }


    /**
     * 获得单个商品信息,主要用于商品的详情页
     * @param spuId 商品id
     * @return RespBean
     */
    @ApiOperation(value = "获得单个商品信息,主要用于商品的详情页")
    @CheckUserLogin(value = false)
    @PostMapping("/getProduct")
    public RespBean getProduct(@RequestParam long spuId){
        return spuInfoService.getProduct(spuId);
    }



    /**
     * 远程调用，判断商品的当前状态,主要用于购物车的
     * @param spuIds 商品的id数组
     * @return RespBean
     */
    @ApiOperation(value = "远程调用，判断商品的当前状态,主要用于购物车的")
    @CheckUserLogin(value = false)
    @PostMapping("/checkSaleCount")
    public RespBean checkSaleCount(@RequestParam long[] spuIds){
        return spuInfoService.checkSaleCount(spuIds);
    }



    /**
     * 逻辑删除
     * @param spuId 商品id
     * @param memberId 会员id
     * @return RespBean
     */
    @ApiOperation(value = "删除商品信息，伪删除，需要登录校验")
    @CheckUserLogin
    @PostMapping("/logicDeleteProduct")
    public RespBean logicDeleteProduct(@RequestParam long spuId, @RequestParam long memberId){
        return spuInfoService.logicDeleteProduct(spuId, memberId);
    }


    /**
     * 真实删除
     * @param spuId 商品id
     * @param memberId 会员id
     * @return RespBean
     */
    @Deprecated
    @PostMapping("/deleteProduct")
    public RespBean deleteProduct(@RequestParam long spuId, @RequestParam long memberId){
        return spuInfoService.deleteProduct(spuId, memberId);
    }

    /**
     * 远程调用获取spuInfo
     * @param spuId 商品id
     * @return RespBean
     */
    @ApiOperation(value = "远程调用，获取商品的详细信息")
    @CheckUserLogin(value = false)
    @PostMapping("/getSpuInfoVo")
    public RespBean getSpuInfoVo(@RequestParam long spuId){
        return spuInfoService.getSpuInfoVo(spuId);
    }


    /**
     * 远程调用获取商品对应的用户id
     * @param spuIds 商品id的数组
     * @return RespBean
     */
    @ApiOperation(value = "远程调用，获取商品发布者的id")
    @CheckUserLogin(value = false)
    @PostMapping("/getMemberIds")
    public RespBean getMemberId(@RequestParam long[] spuIds){
        return spuInfoService.getMemberId(spuIds);
    }


    /**
     * 通过spuIds获取相对于的product信息,
     *      购买商品时，获取商品的详情
     * @param spuIds 商品id
     * @return RespBean
     */
    @ApiOperation(value = "通过多个商品的id，后去商品的详细信息")
    @CheckUserLogin
    @PostMapping("/getProductBySpuIds")
    public RespBean getProductBySpuIds(@RequestParam long[] spuIds){
        return spuInfoService.getProductBySpuIds(spuIds);
    }


    /**
     * 远程调用  判断该商品是否是自己发布的
     * @param memberId
     * @param spuId
     * @return
     */
    @ApiOperation(value = "远程调用，判断该商品是否是自己发布，判断自己是否是发布者")
    @PostMapping("/checkPublisherIsMyself")
    public RespBean checkPublisherIsMyself(@RequestParam Long memberId, @RequestParam Long spuId){
        return spuInfoService.checkPublisherIsMyself(memberId, spuId);
    }


    /**
     * 远程调用  批量判断该商品是否是自己发布的
     * @param memberId
     * @param spuIds
     * @return
     */
    @ApiOperation(value = "远程调用，批量判断这些商品中有没有自己发布的商品，如果有，则返回true")
    @PostMapping("/batchCheckPublisherIsMyself")
    public RespBean batchCheckPublisherIsMyself(@RequestParam Long memberId, @RequestParam Long[] spuIds){
        return spuInfoService.batchCheckPublisherIsMyself(memberId, spuIds);
    }


    /**
     * 远程调用，检查总价是否一致
     * @param spuIds
     * @param price
     * @return
     */
    @ApiOperation(value = "远程调用，检查总价是否一致")
    @PostMapping("/checkTotalPrice")
    RespBean checkTotalPrice(@RequestParam Long[] spuIds, @RequestParam BigDecimal price){
        return spuInfoService.checkProductPrice(spuIds, price);
    }


    /**
     * 通过spuId将商品进行下架处理
     * @param spuId
     * @return
     */
    @ApiOperation(value = "管理员上下架商品")
    @GetMapping("/offShelfProduct")
    RespBean offShelfProduct(@RequestParam Long spuId, @RequestParam Integer status){
        return spuInfoService.offShelfProduct(spuId,status);
    }


}
